xplly'Blog

一、概述

Sentinel是阿里巴巴开源的一款微服务流量控制组件。官网地址：https://sentinelguard.io/zh-cn/index.html

Sentinel 具有以下特征:

丰富的应用场景：Sentinel 承接了阿里巴巴近 10 年的双十一大促流量的核心场景，例如秒杀（即突发流量控制在系统容量可以承受的范围）、消息削峰填谷、集群流量控制、实时熔断下游不可用应用等。
完备的实时监控：Sentinel 同时提供实时的监控功能。您可以在控制台中看到接入应用的单台机器秒级数据，甚至 500 台以下规模的集群的汇总运行情况。
广泛的开源生态：Sentinel 提供开箱即用的与其它开源框架/库的整合模块，例如与 Spring Cloud、Dubbo、gRPC 的整合。您只需要引入相应的依赖并进行简单的配置即可快速地接入 Sentinel。
完善的 SPI 扩展点：Sentinel 提供简单易用、完善的 SPI 扩展接口。您可以通过实现扩展接口来快速地定制逻辑。例如定制规则管理、适配动态数据源等。

Sentinel 分为两个部分:

核心库（Java 客户端）不依赖任何框架/库,能够运行于所有 Java 运行时环境，同时对 Dubbo /Spring Cloud 等框架也有较好的支持。

控制台（Dashboard）基于 Spring Boot 开发，打包后可以直接运行，不需要额外的 Tomcat 等应用容器

1.1 相关概念

Sentinel 可以简单的分为 Sentinel 核心库和 Dashboard。核心库不依赖 Dashboard，但是结合Dashboard 可以取得最好的效果。

使用 Sentinel 来进行熔断保护，主要分为几个步骤:

定义资源
定义规则
检验规则是否生效

资源就是Sentinel要保护的东西

资源是 Sentinel 的关键概念。它可以是 Java 应用程序中的任何内容，可以是一个服务，也可以是一个方法，甚至可以是一段代码。

例如，由应用程序提供的服务，或由应用程序调用的其它应用提供的服务，甚至可以是一段代码。只要通过 Sentinel API 定义的代码，就是资源，能够被 Sentinel 保护起来。大部分情况下，可以使用方法签名，URL，甚至服务名称作为资源名来标示资源。

规则就是用来定义如何进行保护资源的

作用在资源之上, 定义以什么样的方式保护资源，主要包括流量控制规则、熔断降级规则以及系统保护规则。

流量控制在网络传输中是一个常用的概念，它用于调整网络包的发送数据。在网络传输时，任意时间到来的请求往往是随机不可控的，而系统的处理能力是有限的。我们需要根据系统的处理能力对流量进行控制。

流量控制设计理念

流量控制有以下几个角度:

资源的调用关系，例如资源的调用链路，资源和资源之间的关系；
运行指标，例如 QPS、线程池、系统负载等；
控制的效果，例如直接限流、冷启动、排队等。

Sentinel 的设计理念是让您自由选择控制的角度，并进行灵活组合，从而达到想要的效果。

熔断降级就是当检测到调用链路中某个资源出现不稳定的表现，例如请求响应时间长或异常比例升高的时候，则对这个资源的调用进行限制，让请求快速失败，避免影响到其它的资源而导致级联故障。

1.2 系统负载保护

Sentinel 同时提供系统维度的自适应保护能力。当系统负载较高的时候，如果还持续让请求进入可能会导致系统崩溃，无法响应。在集群环境下，会把本应这台机器承载的流量转发到其它的机器上去。如果这个时候其它的机器也处在一个边缘状态的时候，Sentinel 提供了对应的保护机制，让系统的入口流量和系统的负载达到一个平衡，保证系统在能力范围之内处理最多的请求

1.3 工作机制

对主流框架提供适配或者显示的 API，来定义需要保护的资源，并提供设施对资源进行实时统计和调用链路分析。
根据预设的规则，结合对资源的实时统计信息，对流量进行控制。同时，Sentinel 提供开放的接口，方便您定义及改变规则。
Sentinel 提供实时的监控系统，方便您快速了解目前系统的状态。

1.4 簇点网络

当请求进入微服务时，首先会访问DispatcherServlet，然后进入Controller、Service、Mapper，这样的一个调用链就叫做簇点链路。簇点链路中被监控的每一个接口就是一个资源。

默认情况下sentinel会监控SpringMVC的每一个端点（Endpoint，也就是controller中的方法），因此SpringMVC的每一个端点（Endpoint）就是调用链路中的一个资源。

流控、熔断等都是针对簇点链路中的资源来设置的。可以在簇点网络根据按钮对资源进行流量控制、降级熔断、热点参数限流、授权。

1.5 限流

在簇点网络中，对一个资源添加流量控制，QPS表示每秒允许的请求数量，超出会被拦截并报错。

流控模式

在添加限流规则时，点击高级选项，可以选择三种流控模式：

直接：统计当前资源的请求，触发阈值时对当前资源直接限流，也是默认的模式
关联：统计与当前资源相关的另一个资源，触发阈值时，对当前资源限流。
链路：统计从指定链路访问到本资源的请求，触发阈值时，对指定链路限流

流控效果

流控效果是指请求达到流控阈值时应该采取的措施，包括三种：

快速失败：达到阈值后，新的请求会被立即拒绝并抛出FlowException异常。是默认的处理方式。
warm up：预热模式，对超出阈值的请求同样是拒绝并抛出异常。但这种模式阈值会动态变化，从一个较小值逐渐增加到最大阈值。
阈值一般是一个微服务能承担的最大QPS，但是一个服务刚刚启动时，一切资源尚未初始化（冷启动），如果直接将QPS跑到最大值，可能导致服务瞬间宕机。
warm up是应对服务冷启动的一种方案。请求阈值初始值是 maxThreshold / coldFactor，持续指定时长后，逐渐提高到maxThreshold值。而coldFactor的默认值是3.例如，我设置QPS的maxThreshold为10，预热时间为5秒，那么初始阈值就是 10 / 3 ，也就是3，然后在5秒后逐渐增长到10.
排队等待：让所有的请求按照先后次序排队执行，两个请求的间隔不能小于指定时长
当请求超过QPS阈值时，快速失败和warm up 会拒绝新的请求并抛出异常。而排队等待则是让所有请求进入一个队列中，然后按照阈值允许的时间间隔依次执行。后来的请求必须等待前面执行完成，如果请求预期的等待时间超出最大时长，则会被拒绝。
例如：QPS = 5，意味着每200ms处理一个队列中的请求；timeout = 2000，意味着预期等待时长超过2000ms的请求会被拒绝并抛出异常。

二、应用示例

2.1 流控降级示例

Sentinel本地应用流控降级实现分为三步：

创建本地应用
搭建本地Sentinel控制台
本地应用接入本地Sentinel控制台

本地应用创建

依赖

xml

<!--sentinel核心依赖-->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-core</artifactId>
    <version>1.7.2</version>
</dependency>

定义使用限流规则

java

@RestController
public class TestController {

    @GetMapping("hello")
    public String hello(){

        //1.进行限流控制
        try (Entry entry = SphU.entry("Hello")){//限流入口
            return "Hello Sentinel!";//被保护的资源
        } catch (BlockException e) {
            e.printStackTrace();
            return "系统繁忙，请稍候";//被限流或者降级的处理
        }

    }

    /**
     * 定义限流规则
     * @PostConstruct ：在构造函数执行完毕后执行
     */
    @PostConstruct
    public void initFlowRules(){
        //1.创建存放限流规则的集合
        List<FlowRule> rules = new ArrayList<FlowRule>();

        //2.创建限流规则
        FlowRule rule = new FlowRule();
        //定义资源
        rule.setResource("Hello");
        //定义限流规则类型,RuleConstant.FLOW_GRADE_QPS：OPS类型
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        //定义OPS每秒最多只能通过的请求个数
        rule.setCount(2);
        //将限流规则添加到集合中
        rules.add(rule);

        //3.加载限流规则
        FlowRuleManager.loadRules(rules);
    }

}

通过浏览器访问http://localhost:8080/hello，慢速刷新，则持续显示”Hello Sentinel”；快速刷新则会交替出现”Hello Sentinel”和“系统繁忙，请稍候”。这说明对“Hello"资源限流成功。我们还可以通过查看日志获取限流详情

本地Sentinel控制台搭建

參考安裝

应用接入控制台

添加依賴

xml

<!--本地应用接入本地控制台的依赖-->
<dependency>
      <groupId>com.alibaba.csp</groupId>
      <artifactId>sentinel-transport-simple-http</artifactId>
      <version>1.7.2</version>
</dependency>

2.2 与springcloud整合

依赖

xml

<!--sentinel-->
<dependency>
    <groupId>com.alibaba.cloud</groupId> 
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

配置

yml

server:
  port: 8088
spring:
  cloud: 
    sentinel:
      transport:
        dashboard: localhost:8080

使用示例

java

@RestController
public class TestController {

    //定义限流资源和限流讲解回调函数
    @SentinelResource(value = "Sentinel_SpringCloud", blockHandler = "exceptionHandler")
    @GetMapping("ann")
    public String hello() {
        return "Hello Sentinel!";
    }

    // blockHandler函数，原方法调用被限流/降级/系统保护的时候调用
    public String exceptionHandler(BlockException ex) {
        ex.printStackTrace();
        return "系统繁忙，请稍候";
    }
}

在Sentinel控制的中增加关于“Sentinel_SpringCloud”资源的流控规则

启动本地应用并重新通过浏览器访问http://localhost:8080/ann，快慢速刷新几次，查看控制台中的实时监控情况。

2.3 与Feign的集成

Sentinel 适配了 Feign组件。如果想使用，除了引入 spring-cloud-starter-alibaba-sentinel 的依赖外还需要 2 个步骤：

配置文件打开 Sentinel 对 Feign 的支持：feign.sentinel.enabled=true
加入 spring-cloud-starter-openfeign 依赖使 Sentinel starter 中的自动化配置类生效;

依赖

xml

<!--eureka客户端依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

<!--feign的起步依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

<!--Spring Cloud Alibaba Sentinel依赖-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
    <version>2.1.0.RELEASE</version>
</dependency>

启用Eureka

引导类中添加Eureka的服务注解

java

@EnableDiscoveryClient  //开启Eureka客户端发现功能
@SpringBootApplication
@EnableFeignClients //开启feign功能
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

配置

配置文件配置eureka

yaml

#tomcat端口
server:
  port: 9012

#应用的名称
spring:
  application:
    name: sentinel-feign-client
  cloud:
    sentinel:
      transport:
        dashboard: localhost:9000

#eureka的配置
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:9010/eureka  #要注册到的注册中心的地址
      
# 开启 Sentinel 对 Feign 的支持


<NolebasePageProperties />




feign:
  sentinel:
    enabled: true

Feign代理接口

java

@FeignClient(value="sentinel-feign-provider",fallback = FallbackService.class)
public interface FeignAgent {
    @GetMapping("/hello")
    String hello();
}

创建FallbackService

作为流控降级回调类，并在FeignAgent进行流控降级回调配置

java

@Component
public class FallbackService implements FeignAgent {
    @Override
    public String hello() {
        return "系统繁忙，请稍后";
    }
}

创建controller

java

@RestController
public class TestController {

    @Autowired
    private FeignAgent feignAgent;

    @GetMapping("hello")
    public String hello(){
        return feignAgent.hello();
    }
}

测试

启动项目，查看项目是否注册到eureka注册中心中。

浏览器输入http://localhost:9012/hello，查看是否能访问成功。

启动项目，在Sentinel控制中增加关于资源的流控规则，Sentinel和Feign整合时，流控规则的编写形式为：http请求方式:协议://服务名/请求路径跟参数，例如：**GET:http://sentinel-feign-provider/hello**。

通过浏览器输入http://localhost:9012/hello，慢速刷新，则持续显示”Hello Sentinel”；快速刷新则会交替出现”Hello Sentinel”和“系统繁忙，请稍候”。这说明对资源限流成功。

2.4 与gateway集成

Sentinel 提供了 Spring Cloud Gateway 的适配模块，可以提供两种资源维度的限流：

route 维度：即在 Spring 配置文件中配置的路由条目，资源名为对应的 routeId
自定义 API 维度：用户可以利用 Sentinel 提供的 API 来自定义一些 API 分组

依赖

xml

<!--网关的起步依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

<!--eureka注册中心客户端的起步依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

<!--Spring Cloud Alibaba Sentinel依赖-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
    <version>2.1.0.RELEASE</version>
</dependency>

<!--sentinel支持spring cloud gateway的依赖-->
<dependency>
     <groupId>com.alibaba.cloud</groupId>
     <artifactId>spring-cloud-alibaba-sentinel-gateway</artifactId>
     <version>2.1.0.RELEASE</version>
</dependency>

启用Eureka

在引导类中配置eureka客户端开启注解

java

@SpringBootApplication
@EnableDiscoveryClient //开启Eureka客户端发现功能
public class GateWayApplication {
    public static void main(String[] args) {
        SpringApplication.run(GateWayApplication.class, args);
    }
}

配置

在application.yml配置文件中配置应用的端口、应用的名称、eureka配置

yaml

# 端口
server:
  port: 9013

# 应用的名称
spring:
  application:
    name: sentinel-gateway

# eureka配置
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:9010/eureka
      
spring:
  # 网关配置
  cloud:
    gateway:
      routes:
        - id: sentinel-feign-gateway
          # 路由转发路径
          uri: lb://sentinel-feign-client:9012
          # 断言
          predicates:
            - Path=/hello/**
            
spring:
  cloud:
    # sentinel控制台地址
    sentinel:
      transport:
        dashboard: localhost:9000

配置类

创建GatewayConfiguration配置类，配置流控降级回调操作

java

@Component
public class GatewayConfiguration {

    @PostConstruct
    public void doInit() {
        //限流回调函数
        GatewayCallbackManager.setBlockHandler(new BlockRequestHandler() {
            //当请求被限流是调用的方法
            @Override
            public Mono<ServerResponse> handleRequest(ServerWebExchange serverWebExchange, Throwable throwable) {

                return ServerResponse.status(200).syncBody("系统繁忙，请稍候");
            }
        });
    }

}

流控规则测试

启动项目，在Sentinel控制中增加关于资源的流控规则，Sentinel在适配Spring Cloud Gateway时提供了两种配置资料的规则

route 维度：即在 Spring 配置文件中配置的路由条目，资源名为对应的 routeId
自定义 API 维度：用户可以利用 Sentinel 提供的 API 来自定义一些 API 分组

route维度规则定义

在sentinel控制台中增加流控规则，其中API类型选择“Route ID”，API名称为网关配置的路由id，QPS阀值设置为2。

之后，在浏览器中输入http://localhost:9013/hello，慢速刷新，则持续显示”Hello Sentinel”；快速刷新则会交替出现”Hello Sentinel”和“系统繁忙，请稍候”。这说明对资源限流成功。

自定义 API 维度

在sentinel控制台的左侧菜单中选择“API管理”，在弹出的窗口中新增API分组，API名称自己定义，匹配模式选择”前缀“，匹配串设置为网关路由的断言路径。

之后，在sentinel控制台的左侧菜单中选择“流控规则”，其中API类型选择“API分组”，API名称为之前添加的API分组的名称，QPS阀值设置为2。

三、核心知识

3.1 定义资源方式

Sentinel除了基本的定义资源的方式之外，还有其他的定义资源的方式，具体如下：

抛出异常的方式定义资源
返回布尔值方式定义资源
异步调用支持
注解方式定义资源
主流框架的默认适配

抛出异常的方式定义资源

Sentinel中的SphU 包含了 try-catch 风格的 API。用这种方式，当资源发生了限流之后会抛出 BlockException。这个时候可以捕捉异常，进行限流之后的逻辑处理，而我们在入门案例中就使用的此种方式进行定义资源，关键代码如下：

java

try (Entry entry = SphU.entry("Hello")){//使用限流规则监控保护资源
    return "Hello Sentinel!";//被保护的资源
} catch (BlockException e) {
     e.printStackTrace();
     return "系统繁忙，请稍候";//被限流或者降级的处理
}

返回布尔值方式定义资源

Sentinel中的SphO 提供 if-else 风格的 API。用这种方式，当资源发生了限流之后会返回 false，这个时候可以根据返回值，进行限流之后的逻辑处理。

1.在sentinel_quick_start项目中创建TestBooleanController，在TestBooleanController中使用返回布尔值的方式定义资源

java

@RestController
public class TestBooleanController {

    @GetMapping("boolean")
    public boolean hello() {

        //1..进行限流控制
        if (SphO.entry("Sentinel_Boolean")) {//限流入口
            try {
                //被保护的资源
                System.out.println("访问成功");
                return true;
            } finally {
                //SphO.entry(xxx)需要与 SphO.exit()方法成对出现，否则会导致调用链记录异常，抛出ErrorEntryFreeException异常
                SphO.exit();//限流出口，
            }
        } else {
            //被限流或者降级的处理
            System.out.println("系统繁忙，请稍候");
            return false;
        }

    }
}

注意：

SphO.entry(xxx)需要与 SphO.exit()方法成对出现，否则会导致调用链记录异常，抛出ErrorEntryFreeException异常。

2.运行测试

在Sentinel控制的中增加关于“Sentinel_Boolean”资源的流控规则

通过浏览器访问http://localhost:8080/boolean，慢速刷新，则持续显示”true”；而Idea打印台显示“访问成功”，快速刷新则会交替出现“true”和“false”，打印台则会交替出现“访问成功”和“系统繁忙，请稍候”，这说明使用返回布尔值方式对“Sentinel_Boolean"资源限流成功。

异步调用支持

Sentinel 支持异步调用链路的统计。在异步调用中，需要通过 SphU.asyncEntry(xxx) 方法定义资源，并通常需要在异步的回调函数中调用 exit 方法。

1.在本地应用的引导类中添加@EnableAsync，表示springboot项目开始异步调用支持

java

@SpringBootApplication
@EnableAsync
public class SentinelQuickStartApplication {

    public static void main(String[] args) {
        SpringApplication.run(SentinelQuickStartApplication.class, args);
    }

}

2.创建AsyncService编写异步调用的方法

java

@Service
public class AsyncService {

	//@Async表示方法为异步调用方法
    @Async
    public void hello(){
        System.out.println("异步开始-----");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("完成异步----");
    }

}

3.创建TestAsyncController，实现异步调用限流控制

java

@RestController
public class TestAsyncController {

    @Autowired
    private AsyncService asyncService;

    @GetMapping("async")
    public void hello() {

        //1.进行限流控制
        AsyncEntry asyncEntry = null;
        try {
            asyncEntry = SphU.asyncEntry("Sentinel_Async");//限流入口
            asyncService.hello();//异步方法调用
        } catch (BlockException e) {//被限流或者降级的处理
            System.out.println("系统繁忙，请稍候");
        }finally {
            if (asyncEntry != null){
                asyncEntry.exit();//限流出口，
            }
        }
    }

}

4.运行测试

在Sentinel控制的中增加关于“Sentinel_Async”资源的流控规则

通过浏览器输入http://localhost:8080/async，慢速刷新，查看Idea的打印台，会发现打印台会打印出“异步开始-”；快速刷新可以查看Idea的打印台，则会发现打印台会交替打印出“异步开始”和“系统繁忙，请稍候”，这也说明对“Sentinel_Boolean"资源限流成功。

注解方式定义资源

Sentinel 支持通过 @SentinelResource 注解定义资源并配置 blockHandler函数来进行限流之后的处理。

1.在本地应用的pom.xml文件中引入依赖

因为Sentinel中使用AspectJ 的扩展用于自动定义资源、处理 BlockException 等，所以需要在项目中引入sentinel-annotation-aspectj依赖。

xml

<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-annotation-aspectj</artifactId>
    <version>1.7.2</version>
</dependency>

2.创建AspectJ 的配置类

java

@Configuration
public class SentinelAspectConfiguration {

    @Bean
    public SentinelResourceAspect sentinelResourceAspect() {
        return new SentinelResourceAspect();
    }
}

3.创建TestAnnController，实现限流控制

java

@RestController
public class TestAnnController {

    //定义限流资源和限流讲解回调函数
    @SentinelResource(value = "Sentinel_Ann", blockHandler = "exceptionHandler")
    @GetMapping("ann")
    public String hello() {
        return "Hello Sentinel!";
    }

    // blockHandler函数，原方法调用被限流/降级/系统保护的时候调用
    public String exceptionHandler(BlockException ex) {
        ex.printStackTrace();
        return "系统繁忙，请稍候";
    }

}

@SentinelResource 注解用来标识资源是否被限流、降级。上述例子中该注解的属性 'Sentinel_Ann' 表示资源名。
@SentinelResource 还提供了其它额外的属性如 blockHandler来指定被限流后的操作。

4.运行测试

在Sentinel控制的中增加关于“Sentinel_Ann”资源的流控规则

通过浏览器输入http://localhost:8080/ann，慢速刷新，则持续显示”Hello Sentinel”；快速刷新则会交替出现”Hello Sentinel”和“系统繁忙，请稍候”。这说明对“Sentinel_Ann"资源限流成功。

主流框架的默认适配

为了减少开发的复杂程度，我们对大部分的主流框架，例如 Web Servlet、Dubbo、Spring Cloud、gRPC、Spring WebFlux、Reactor 等都做了适配。您只需要引入对应的依赖即可方便地整合 Sentinel。

3.2 热点参数限流

热点参数限流是分别统计参数值相同的请求，判断是否超过QPS阈值。

配置示例：

代表的含义是：对hot这个资源的0号参数（第一个参数）做统计，每1秒相同参数值的请求数不能超过5。

该示例是对所有的商品做限制，每个的QPS都为5.对部分商品吸纳之，即参数索引为0的特定值的配置，需要在高级选项中添加。

结合上一个配置，这里的含义是对0号的long类型参数限流，每1秒相同参数的QPS不能超过5，有两个例外：

•如果参数值是100，则每1秒允许的QPS为10

•如果参数值是101，则每1秒允许的QPS为15

注意

热点参数限流对默认的SpringMVC资源无效，需要利用@SentinelResource注解标记资源。

3.3 隔离和降级

限流是一种预防措施，虽然限流可以尽量避免因高并发而引起的服务故障，但服务还会因为其它原因而故障。

而要将这些故障控制在一定范围，避免雪崩，就要靠线程隔离（舱壁模式）和熔断降级手段了。

线程隔离是调用者在调用服务提供者时，给每个调用的请求分配独立线程池，出现故障时，最多消耗这个线程池内资源，避免把调用者的所有资源耗尽。

熔断降级：是在调用方这边加入断路器，统计对服务提供者的调用，如果调用的失败比例过高，则熔断该业务，不允许访问该服务的提供者了。

不管是线程隔离还是熔断降级，都是对客户端（调用方）的保护。需要在调用方 发起远程调用时做线程隔离、或者服务熔断。

而我们的微服务远程调用都是基于Feign来完成的，因此我们需要将Feign与Sentinel整合，在Feign里面实现线程隔离和服务熔断。

1. Rest实现熔断

Spring Cloud Alibaba Sentinel 支持对 RestTemplate 的服务调用使用 Sentinel 进行保护，在构造RestTemplate bean的时候需要加上 @SentinelRestTemplate 注解

@SentinelRestTemplate 注解的属性支持限流( blockHandler , blockHandlerClass )和降级( fallback , fallbackClass )的处理。
其中 blockHandler 或 fallback 属性对应的方法必须是对应 blockHandlerClass 或 fallbackClass 属性中的静态方法。该方法的参数跟返回值跟
org.springframework.http.client.ClientHttpRequestInterceptor#interceptor 方法一致，其中参数多出了一个 BlockException 参数用于获取 Sentinel 捕获的异常。

Sentinel RestTemplate 限流的资源规则提供两种粒度：

httpmethod:schema://host:port/path ：协议、主机、端口和路径

httpmethod:schema://host:port ：协议、主机和端口

2. FeignClient整合Sentinel

降级

修改配置

yaml

feign:
  sentinel:
    enabled: true # 开启feign对sentinel的支持

编写失败降级逻辑
业务失败后，不能直接报错，而应该返回用户一个友好提示或者默认结果，这个就是失败降级逻辑。
给FeignClient编写失败后的降级逻辑
①方式一：FallbackClass，无法对远程调用的异常做处理
②方式二：FallbackFactory，可以对远程调用的异常做处理。
- 给FeignClient编写FallbackFactory并注册为Bean
- 将FallbackFactory配置到FeignClient
Feign 对应的接口中的资源名策略定义：httpmethod:protocol://requesturl。 @FeignClient 注解中的所有属性，Sentinel 都做了兼容。

3. 线程隔离

线程隔离有两种方式实现：

线程池隔离：给每个服务调用业务分配一个线程池，利用线程池本身实现隔离效果
信号量隔离（Sentinel默认采用）不创建线程池，而是计数器模式，记录业务使用的线程数量，达到信号量上限时，禁止新的请求。

线程隔离在添加限流规则时，选取线程数。线程数是该资源能使用用的tomcat线程数的最大值。也就是通过限制线程数量，实现线程隔离（舱壁模式）。

4. 熔断降级

熔断降级是解决雪崩问题的重要手段。其思路是由断路器统计服务调用的异常比例、慢请求比例，如果超出阈值则会熔断该服务。即拦截访问该服务的一切请求；而当服务恢复时，断路器会放行访问该服务的请求。

通过并发线程数进行限制

Sentinel 通过限制资源并发线程的数量，来减少不稳定资源对其它资源的影响。当某个资源出现不稳定的情况下，例如响应时间变长，对资源的直接影响就是会造成线程数的逐步堆积。当线程数在特定资源上堆积到一定的数量之后，对该资源的新请求就会被拒绝。堆积的线程完成任务后才开始继续接收请求。

通过响应时间对资源进行降级

除了对并发线程数进行控制以外，Sentinel 还可以通过响应时间来快速降级不稳定的资源。当依赖的资源出现响应时间过长后，所有对该资源的访问都会被直接拒绝，直到过了指定的时间窗口之后才重新恢复断路器控制熔断和放行是通过状态机来完成的：

状态机包括三个状态：

closed：关闭状态，断路器放行所有请求，并开始统计异常比例、慢请求比例。超过阈值则切换到open状态
open：打开状态，服务调用被熔断，访问被熔断服务的请求会被拒绝，快速失败，直接走降级逻辑。Open状态5秒后会进入half-open状态
half-open：半开状态，放行一次请求，根据执行结果来判断接下来的操作。
- 请求成功：则切换到closed状态
- 请求失败：则切换到open状态

断路器熔断策略有三种：慢调用、异常比例、异常数

慢调用
业务的响应时长（RT）大于指定时长的请求认定为慢调用请求。在指定时间内，如果请求数量超过设定的最小数量，慢调用比例大于设定的阈值，则触发熔断。
例如：
解读：RT超过500ms的调用是慢调用，统计最近10000ms内的请求，如果请求量超过10次，并且慢调用比例不低于0.5，则触发熔断，熔断时长为5秒。然后进入half-open状态，放行一次请求做测试。
异常比例、异常数
统计指定时间内的调用，如果调用次数超过指定请求数，并且出现异常的比例达到设定的比例阈值（或超过指定异常数），则触发熔断。
例如，一个异常比例设置：
解读：统计最近1000ms内的请求，如果请求量超过10次，并且异常比例不低于0.4，则触发熔断。
一个异常数设置：
解读：统计最近1000ms内的请求，如果请求量超过10次，并且异常比例不低于2次，则触发熔断。

熔断降级实现

熔断降级会在调用链路中某个资源出现不稳定状态时（例如调用超时或异常比例升高），对这个资源的调用进行限制，让请求快速失败，避免影响到其它的资源而导致级联错误。当资源被降级后，在接下来的降级时间窗口之内，对该资源的调用都自动熔断（默认行为是抛出 DegradeException）。

重要的属性

Field	说明	默认值
resource	资源名，即限流规则的作用对象
count	阈值
grade	熔断策略，支持秒级 RT/秒级异常比例/分钟级异常数	秒级平均 RT
timeWindow	降级的时间，单位为 s
rtSlowRequestAmount	RT 模式下 1 秒内连续多少个请求的平均 RT 超出阈值方可触发熔断（1.7.0 引入）	5
minRequestAmount	异常熔断的触发最小请求数，请求数小于该值时即使异常比率超出阈值也不会熔断（1.7.0 引入）	5

同一个资源可以同时有多个降级规则。

熔断策略详解：

平均响应时间 (DEGRADE_GRADE_RT)：当 1s 内持续进入 N 个请求，对应时刻的平均响应时间（秒级）均超过阈值（count，以 ms 为单位），那么在接下的时间（DegradeRule 中的 timeWindow，以 s 为单位）之内，对这个方法的调用都会自动地熔断（抛出 DegradeException）。
异常比例 (DEGRADE_GRADE_EXCEPTION_RATIO)：当资源的每秒请求量 >= N（可配置），并且每秒异常总数占通过量的比值超过阈值（DegradeRule 中的 count）之后，资源进入降级状态，即在接下的时间（DegradeRule 中的 timeWindow，以 s 为单位）之内，对这个方法的调用都会自动地返回。异常比率的阈值范围是 [0.0, 1.0]，代表 0% - 100%。
异常数 (DEGRADE_GRADE_EXCEPTION_COUNT)：当资源近 1 分钟的异常数目超过阈值之后会进行熔断。注意由于统计时间是分钟级别的，若 timeWindow小于 60s，则结束熔断状态后仍可能再进入熔断状态。

这里演示如何使用平均响应时间(DEGRADE_GRADE_RT)配置规则

实现步骤

熔断降级规则设置有两种方式

本地代码设置
在Sentinel控制台动态设置

平均响应时间

本地代码设置

1.导入资料中的sentinel_rule项目。

2.创建DegradeController，在其中编写修改以下代码

java

@RestController
public class DegradeController {

    //定义限流资源和限流讲解回调函数
    @SentinelResource(value = "Sentinel_Rule",fallback = "exceptionHandler")
    @GetMapping("degrade")
    public String hello() {

        return "Hello Sentinel!";
    }

    // 降级方法
    public String exceptionHandler() {
        return "系统繁忙，请稍候";
    }
}

3.在DegradeController中编写以下代码

java

@PostConstruct
private void initDegradeRule() {
        //1.创建存放熔断降级规则的集合
        List<DegradeRule> rules = new ArrayList<>();

        //2.创建熔断降级规则
        DegradeRule rule = new DegradeRule();
        //定义资源
        rule.setResource("Sentinel_Rule");
        //阈值
        rule.setCount(0.01);
        //定义规则类型,RuleConstant.DEGRADE_GRADE_RT：熔断降级(秒级 RT)类型
    	/**
         * 当资源的平均响应时间超过阈值（DegradeRule中的count，以ms为单位）之后，资源进入准降级状态。
         * 接下来如果持续进入 5 个请求，它们的 RT 都持续超过这个阈值，
         * 那么在接下的时间窗口（DegradeRule 中的 timeWindow，以 s 为单位）之内，
         * 将会抛出 DegradeException。
         */
        rule.setGrade(RuleConstant.DEGRADE_GRADE_RT);
        //降级的时间，单位为 s
        rule.setTimeWindow(10);
        //将熔断降级规则添加到集合中
        rules.add(rule);

        //3.加载熔断降级规则
        DegradeRuleManager.loadRules(rules);
}

运行测试

通过浏览器输入http://localhost:8080/ann，慢速刷新，则持续显示”Hello Sentinel”；快速刷新多次之后则会出现“系统繁忙，请稍候”，并且之后再次刷新都显示“系统繁忙，请稍候”，等待10秒之后，则再次显示“Hello Sentinel”，这说明对资源限流成功。

在Sentinel控制台动态设置

将DegradeController中的代码设置熔断降级规则删除，重启项目，在Sentinel控制台动态设置熔断降级规则。

在Sentinel控制台的左侧菜单中选择“降级规则”，点击“新增降级规则”按钮，设置熔断降级规则，其中降级策略设选择“RT”。

3.4 授权

授权规则可以对请求方来源做判断和控制。有白名单和黑名单两种方式。

白名单：来源（origin）在白名单内的调用者允许访问
黑名单：来源（origin）在黑名单内的调用者不允许访问

点击左侧菜单的授权，可以看到授权规则：

资源名：就是受保护的资源，例如/order/
流控应用：是来源者的名单，
- 如果是勾选白名单，则名单中的来源被许可访问。
- 如果是勾选黑名单，则名单中的来源被禁止访问。

Sentinel是通过RequestOriginParser这个接口的parseOrigin来获取请求的来源的。

java

public interface RequestOriginParser {
    /**
     * 从请求request对象中获取origin，获取方式自定义
     */
    String parseOrigin(HttpServletRequest request);
}

从request对象中，获取请求者的origin值并返回。默认情况下，sentinel不管请求者从哪里来，返回值永远是default。因此需要自定义这个接口的实现，让不同的请求，返回不同的origin。

java

import com.alibaba.csp.sentinel.adapter.spring.webmvc.callback.RequestOriginParser;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import javax.servlet.http.HttpServletRequest;

@Component
public class HeaderOriginParser implements RequestOriginParser {
    @Override
    public String parseOrigin(HttpServletRequest request) {
        // 1.获取请求头
        String origin = request.getHeader("origin");
        // 2.非空判断
        if (StringUtils.isEmpty(origin)) {
            origin = "blank";
        }
        return origin;
    }
}

网关Gateway可以添加请求头信息。使项目只允许微服务只放行来自gateway的请求。

gateway配置

yaml

spring:
  cloud:
    gateway:
      default-filters: # 添加origin头，值为gateway
        - AddRequestHeader=origin,gateway
      routes:
       # ...略

授权配置应用名为gateway，授权类型为白名单。仅能通过gateway访问。

3.5 系统规则

系统保护规则是从应用级别的入口流量进行控制，从单台机器的总体 Load、RT、入口 QPS 、CPU使用率和线程数五个维度监控应用数据，让系统尽可能跑在最大吞吐量的同时保证系统整体的稳定性。系统保护规则是应用整体维度的，而不是资源维度的，并且仅对入口流量 (进入应用的流量) 生效。

Load（仅对 Linux/Unix-like 机器生效）：当系统 load1 超过阈值，且系统当前的并发线程数超过系统容量时才会触发系统保护。系统容量由系统的 maxQps * minRt 计算得出。设定参考值一般是 CPU cores * 2.5。
RT：当单台机器上所有入口流量的平均 RT 达到阈值即触发系统保护，单位是毫秒。
线程数：当单台机器上所有入口流量的并发线程数达到阈值即触发系统保护。
入口 QPS：当单台机器上所有入口流量的 QPS 达到阈值即触发系统保护。
CPU使用率：当单台机器上所有入口流量的 CPU使用率达到阈值即触发系统保护。

3.6 异常

默认情况下，发生限流、降级、授权拦截时，都会抛出异常到调用方。异常结果都是flow limmiting（限流）。这样不够友好，无法得知是限流还是降级还是授权拦截。

如果要自定义异常返回结果，则需实现BlockExceptionHandler接口：

java

public interface BlockExceptionHandler {
    /**
     * 处理请求被限流、降级、授权拦截时抛出的异常：BlockException
     */
    void handle(HttpServletRequest request, HttpServletResponse response, BlockException e) throws Exception;
}

参数

这个方法有三个参数：

HttpServletRequest request：request对象
HttpServletResponse response：response对象
BlockException e：被sentinel拦截时抛出的异常

异常子类

这里的BlockException包含多个不同的子类：

异常	说明
FlowException	限流异常
ParamFlowException	热点参数限流的异常
DegradeException	降级异常
AuthorityException	授权规则异常
SystemBlockException	系统规则异常

自定义异常处理类

java

import com.alibaba.csp.sentinel.adapter.spring.webmvc.callback.BlockExceptionHandler;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.authority.AuthorityException;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeException;
import com.alibaba.csp.sentinel.slots.block.flow.FlowException;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowException;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Component
public class SentinelExceptionHandler implements BlockExceptionHandler {
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, BlockException e) throws Exception {
        String msg = "未知异常";
        int status = 429;

        if (e instanceof FlowException) {
            msg = "请求被限流了";
        } else if (e instanceof ParamFlowException) {
            msg = "请求被热点参数限流";
        } else if (e instanceof DegradeException) {
            msg = "请求被降级了";
        } else if (e instanceof AuthorityException) {
            msg = "没有权限访问";
            status = 401;
        }

        response.setContentType("application/json;charset=utf-8");
        response.setStatus(status);
        response.getWriter().println("{\"msg\": " + msg + ", \"status\": " + status + "}");
    }
}

java

//异常处理页面
@Component
public class ExceptionHandlerPage implements UrlBlockHandler {
    //BlockException 异常接口,包含Sentinel的五个异常
    // FlowException 限流异常 
    // DegradeException 降级异常
    // ParamFlowException 参数限流异常
    // AuthorityException 授权异常 
    // SystemBlockException 系统负载异常
    @Override 
    public void blocked(HttpServletRequest request, HttpServletResponse response, BlockException e) throws IOException { 
        response.setContentType("application/json;charset=utf-8");
        ResponseData data = null;
        if (e instanceof FlowException) { 
            data = new ResponseData(-1, "接口被限流了..."); 
        } else if (e instanceof DegradeException) { 
            data = new ResponseData(-2, "接口被降级了...");
        }
        response.getWriter().write(JSON.toJSONString(data)); 
    } 
}
@Data
@AllArgsConstructor//全参构造 
@NoArgsConstructor//无参构造 
class ResponseData { private int code; private String message; }

3.7 @SentinelResource使用

在定义了资源点之后，我们可以通过Dashboard来设置限流和降级策略来对资源点进行保护。同时还能通过@SentinelResource来指定出现异常时的处理策略。

主要参数

@SentinelResource 用于定义资源，并提供可选的异常处理和 fallback 配置项。其主要参数如下:

属性	作用
value	资源名称
entryType	entry类型，标记流量的方向，取值IN/OUT，默认是OUT
blockHandler	处理BlockException的函数名称,函数要求： 1. 必须是 public 2.返回类型参数与原方法一致 3. 默认需和原方法在同一个类中。若希望使用其他类的函数，可配置 blockHandlerClass ，并指定blockHandlerClass里面的方法。
blockHandlerClass	存放blockHandler的类,对应的处理函数必须static修饰。
fallback	用于在抛出异常的时候提供fallback处理逻辑。fallback函数可以针对所有类型的异常（除了 exceptionsToIgnore 里面排除掉的异常类型）进行处理。函数要求： 1. 返回类型与原方法一致 2. 参数类型需要和原方法相匹配 3. 默认需和原方法在同一个类中。若希望使用其他类的函数，可配置 fallbackClass ，并指定fallbackClass里面的方法。
fallbackClass	存放fallback的类。对应的处理函数必须static修饰。
defaultFallback	用于通用的 fallback 逻辑。默认fallback函数可以针对所有类型的异常进行处理。若同时配置了 fallback 和 defaultFallback，以fallback为准。函数要求： 1. 返回类型与原方法一致 2. 方法参数列表为空，或者有一个 Throwable 类型的参数。 3. 默认需要和原方法在同一个类中。若希望使用其他类的函数，可配置 fallbackClass ，并指定 fallbackClass 里面的方法。
exceptionsToIgnore	指定排除掉哪些异常。排除的异常不会计入异常统计，也不会进入 fallback逻辑，而是原样抛出。
exceptionsToTrace	需要trace的异常

若 blockHandler 和 fallback 都进行了配置，则被限流降级而抛出 BlockException 时只会

进入 blockHandler 处理逻辑。若未配置 blockHandler 、 fallback 和 defaultFallback ，则被限流降级时会将 BlockException 直接抛出。

定义限流和降级后的处理方法

方式1：直接将限流和降级方法定义在方法中

java

@Service 
@Slf4j 
public class OrderServiceImpl3 { 
    int i = 0;
    @SentinelResource( value = "message", 
                      blockHandler = "blockHandler",//指定发生BlockException时进入的方法 
                      fallback = "fallback"//指定发生Throwable时进入的方法
                      )
    public String message() { 
        i++;
        if (i % 3 == 0) { 
            throw new RuntimeException(); 
        }
        return "message"; 
    }
    //BlockException时进入的方法
    public String blockHandler(BlockException ex) {
        log.error("{}", ex); 
        return "接口被限流或者降级了...";
    }
    //Throwable时进入的方法
    public String fallback(Throwable throwable) { 
        log.error("{}", throwable);
        return "接口发生异常了..."; 
    }
}

方式二: 将限流和降级方法外置到单独的类中

java

@Service
@Slf4j 
public class OrderServiceImpl3 {
    int i = 0; 
    @SentinelResource( value = "message", 
                      blockHandlerClass = OrderServiceImpl3BlockHandlerClass.class, 
                      blockHandler = "blockHandler", 
                      fallbackClass = OrderServiceImpl3FallbackClass.class, 
                      fallback = "fallback" )
    public String message() { 
        i++; 
        if (i % 3 == 0) {
            throw new RuntimeException(); 
        }
        return "message4";
    } 
}
@Slf4j 
public class OrderServiceImpl3BlockHandlerClass { 
    //注意这里必须使用static修饰方法 
    public static String blockHandler(BlockException ex) {
        log.error("{}", ex); return "接口被限流或者降级了..."; 
    }
}
@Slf4j 
public class OrderServiceImpl3FallbackClass { 
    //注意这里必须使用static修饰方法 
    public static String fallback(Throwable throwable) {
        log.error("{}", throwable);
        return "接口发生异常了...";
    } 
}

3.8 @SentinelRestTemplate

@SentinelRestTemplate对 RestTemplate 的服务调用使用 Sentinel 进行保护

@SentinelRestTemplate 注解的属性支持限流( blockHandler , blockHandlerClass )和降级( fallback , fallbackClass )的处理。

其中 blockHandler 或 fallback 属性对应的方法必须是对应 blockHandlerClass 或 fallbackClass 属性中的静态方法。该方法的参数跟返回值跟 org.springframework.http.client.ClientHttpRequestInterceptor#interceptor 方法一致，其中参数多出了一个 BlockException 参数用于获取 Sentinel 捕获的异常。

Sentinel RestTemplate 限流的资源规则提供两种粒度：

httpmethod:schema://host:port/path ：协议、主机、端口和路径

httpmethod:schema://host:port ：协议、主机和端口

3.9 规则持久化

sentinel的所有规则都是内存存储，重启后所有规则都会丢失。在生产环境下，我们必须确保这些规则的持久化，避免丢失。

规则是否能持久化，取决于规则管理模式，sentinel支持三种规则管理模式：

原始模式：Sentinel的默认模式，将规则保存在内存，重启服务会丢失。
pull模式

1. pull模式

pull模式：控制台将配置的规则推送到Sentinel客户端，而客户端会将配置规则保存在本地文件或数据库中。以后会定时去本地文件或数据库中查询，更新本地规则。

2. push模式

push模式：控制台将配置规则推送到远程配置中心，例如Nacos。Sentinel客户端监听Nacos，获取配置变更的推送消息，完成本地配置更新。

自定义实现持久化

处理类

java

package com.itheima.config;

import com.alibaba.csp.sentinel.command.handler.ModifyParamFlowRulesCommandHandler;
import com.alibaba.csp.sentinel.datasource.*;
import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.block.authority.AuthorityRule;
import com.alibaba.csp.sentinel.slots.block.authority.AuthorityRuleManager;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRule;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRuleManager;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRuleManager;
import com.alibaba.csp.sentinel.slots.system.SystemRule;
import com.alibaba.csp.sentinel.slots.system.SystemRuleManager;
import com.alibaba.csp.sentinel.transport.util.WritableDataSourceRegistry;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import org.springframework.beans.factory.annotation.Value;

import java.io.File;
import java.io.IOException;
import java.util.List;

public class FilePersistence implements InitFunc {

    @Value("spring.application.name")
    private String appcationName;

    @Override
    public void init() throws Exception {
        String ruleDir = System.getProperty("user.home") + "/sentinel-rules/" + appcationName;
        String flowRulePath = ruleDir + "/flow-rule.json";
        String degradeRulePath = ruleDir + "/degrade-rule.json";
        String systemRulePath = ruleDir + "/system-rule.json";
        String authorityRulePath = ruleDir + "/authority-rule.json";
        String paramFlowRulePath = ruleDir + "/param-flow-rule.json";

        this.mkdirIfNotExits(ruleDir);
        this.createFileIfNotExits(flowRulePath);
        this.createFileIfNotExits(degradeRulePath);
        this.createFileIfNotExits(systemRulePath);
        this.createFileIfNotExits(authorityRulePath);
        this.createFileIfNotExits(paramFlowRulePath);

        // 流控规则
        ReadableDataSource<String, List<FlowRule>> flowRuleRDS = new FileRefreshableDataSource<>(
                flowRulePath,
                flowRuleListParser
        );
        FlowRuleManager.register2Property(flowRuleRDS.getProperty());
        WritableDataSource<List<FlowRule>> flowRuleWDS = new FileWritableDataSource<>(
                flowRulePath,
                this::encodeJson
        );
        WritableDataSourceRegistry.registerFlowDataSource(flowRuleWDS);

        // 降级规则
        ReadableDataSource<String, List<DegradeRule>> degradeRuleRDS = new FileRefreshableDataSource<>(
                degradeRulePath,
                degradeRuleListParser
        );
        DegradeRuleManager.register2Property(degradeRuleRDS.getProperty());
        WritableDataSource<List<DegradeRule>> degradeRuleWDS = new FileWritableDataSource<>(
                degradeRulePath,
                this::encodeJson
        );
        WritableDataSourceRegistry.registerDegradeDataSource(degradeRuleWDS);

        // 系统规则
        ReadableDataSource<String, List<SystemRule>> systemRuleRDS = new FileRefreshableDataSource<>(
                systemRulePath,
                systemRuleListParser
        );
        SystemRuleManager.register2Property(systemRuleRDS.getProperty());
        WritableDataSource<List<SystemRule>> systemRuleWDS = new FileWritableDataSource<>(
                systemRulePath,
                this::encodeJson
        );
        WritableDataSourceRegistry.registerSystemDataSource(systemRuleWDS);

        // 授权规则
        ReadableDataSource<String, List<AuthorityRule>> authorityRuleRDS = new FileRefreshableDataSource<>(
                authorityRulePath,
                authorityRuleListParser
        );
        AuthorityRuleManager.register2Property(authorityRuleRDS.getProperty());
        WritableDataSource<List<AuthorityRule>> authorityRuleWDS = new FileWritableDataSource<>(
                authorityRulePath,
                this::encodeJson
        );
        WritableDataSourceRegistry.registerAuthorityDataSource(authorityRuleWDS);

        // 热点参数规则
        ReadableDataSource<String, List<ParamFlowRule>> paramFlowRuleRDS = new FileRefreshableDataSource<>(
                paramFlowRulePath,
                paramFlowRuleListParser
        );
        ParamFlowRuleManager.register2Property(paramFlowRuleRDS.getProperty());
        WritableDataSource<List<ParamFlowRule>> paramFlowRuleWDS = new FileWritableDataSource<>(
                paramFlowRulePath,
                this::encodeJson
        );
        ModifyParamFlowRulesCommandHandler.setWritableDataSource(paramFlowRuleWDS);
    }

    private Converter<String, List<FlowRule>> flowRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<FlowRule>>() {
            }
    );
    private Converter<String, List<DegradeRule>> degradeRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<DegradeRule>>() {
            }
    );
    private Converter<String, List<SystemRule>> systemRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<SystemRule>>() {
            }
    );

    private Converter<String, List<AuthorityRule>> authorityRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<AuthorityRule>>() {
            }
    );

    private Converter<String, List<ParamFlowRule>> paramFlowRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<ParamFlowRule>>() {
            }
    );

    private void mkdirIfNotExits(String filePath) throws IOException {
        File file = new File(filePath);
        if (!file.exists()) {
            file.mkdirs();
        }
    }

    private void createFileIfNotExits(String filePath) throws IOException {
        File file = new File(filePath);
        if (!file.exists()) {
            file.createNewFile();
        }
    }

    private <T> String encodeJson(T t) {
        return JSON.toJSONString(t);
    }
}

在resources下创建配置目录 META-INF/services ,然后添加文件

com.alibaba.csp.sentinel.init.InitFunc

在文件中添加配置类的全路径

com.itheima.config.FilePersistence

通过nacos获取配置

客户端配置nacos地址即监听的配置

yaml

spring:
  cloud:
    sentinel:
      datasource:
        flow:
          nacos:
            server-addr: localhost:8848 # nacos地址
            dataId: orderservice-flow-rules
            groupId: SENTINEL_GROUP
            rule-type: flow # 还可以是：degrade、authority、param-flow

修改sentinel源码
去除sentinel-datasource-nacos的scope。
修改rule/nacos/NacosConfig类。读取application.properties获取nacos地址。
添加配置
properties
```
nacos.addr=localhost:8848
```
修改com.alibaba.csp.sentinel.dashboard.controller.v2包下的FlowControllerV2类
将flowRuleDefaultProvider/flowRuleDefaultPublisher修改为 flowRuleNacosProvider/flowRuleNacosPublisher
修改前端页面，将/sidebar/sidebar.html中的dashboard.flow 流控规则-V1 相关放开并修改为流控规则-Nacos
打包重新启动。

3.10 流量控制实现

Sentinel 的所有规则都可以在内存态中动态地查询及修改，修改之后立即生效。同时 Sentinel 也提供相关 API，供您来定制自己的规则策略。

Sentinel 主要支持以下几种规则：

流量控制规则
熔断降级规则
系统保护规则
来源访问控制规则
动态规则扩展

流量控制规则实现

流量控制（flow control），其原理是监控应用流量的 QPS 或并发线程数等指标，当达到指定的阈值时对流量进行控制，以避免被瞬时的流量高峰冲垮，从而保障应用的高可用性。

流量控制主要有两种方式

并发线程数：并发线程数限流用于保护业务线程数不被耗尽
QPS：当 QPS 超过某个阈值的时候，则采取措施进行流量控制

一条限流规则主要由下面几个因素组成，我们可以组合这些元素来实现不同的限流效果：

resource：资源名，即限流规则的作用对象
count: 限流阈值
grade: 限流阈值类型（QPS 或并发线程数）
limitApp: 流控针对的调用来源，若为 default 则不区分调用来源
strategy: 调用关系限流策略
controlBehavior: 流量控制效果（直接拒绝、Warm Up、匀速排队）
- 直接拒绝（RuleConstant.CONTROL_BEHAVIOR_DEFAULT）方式是默认的流量控制方式，当QPS超过任意规则的阈值后，新的请求就会被立即拒绝，拒绝方式为抛出FlowException。这种方式适用于对系统处理能力确切已知的情况下，比如通过压测确定了系统的准确水位时。
- Warm Up（RuleConstant.CONTROL_BEHAVIOR_WARM_UP）方式，即预热/冷启动方式。当系统长期处于低水位的情况下，当流量突然增加时，直接把系统拉升到高水位可能瞬间把系统压垮。通过"冷启动"，让通过的流量缓慢增加，在一定时间内逐渐增加到阈值上限，给冷系统一个预热的时间，避免冷系统被压垮。
- 排队等待（RuleConstant.CONTROL_BEHAVIOR_RATE_LIMITER）方式会严格控制请求通过的间隔时间，也即是让请求以均匀的速度通过，对应的是漏桶算法。

同一个资源可以同时有多个限流规则，检查规则时会依次检查。

3.11 系统自适应保护实现

Sentinel 系统自适应限流从整体维度对应用入口流量进行控制，结合应用的 Load、CPU 使用率、总体平均 RT、入口 QPS 和并发线程数等几个维度的监控指标，通过自适应的流控策略，让系统的入口流量和系统的负载达到一个平衡，让系统尽可能保持最大吞吐量的同时保证系统整体的稳定性。

系统保护规则是应用整体维度的，而不是资源维度的，并且仅对入口流量生效。入口流量指的是进入应用的流量（EntryType.IN），比如 Web 服务或 Dubbo 服务端接收的请求，都属于入口流量。

支持模式

系统规则支持以下的模式

Load 自适应（仅对 Linux/Unix-like 机器生效）：系统的 load1 作为启发指标，进行自适应系统保护。当系统 load1 超过设定的启发值，且系统当前的并发线程数超过估算的系统容量时才会触发系统保护（BBR 阶段）。系统容量由系统的 maxQps * minRt 估算得出。设定参考值一般是 CPU cores * 2.5。
CPU usage（1.5.0+ 版本）：当系统 CPU 使用率超过阈值即触发系统保护（取值范围 0.0-1.0），比较灵敏。
平均 RT：当单台机器上所有入口流量的平均 RT 达到阈值即触发系统保护，单位是毫秒。
并发线程数：当单台机器上所有入口流量的并发线程数达到阈值即触发系统保护。
入口 QPS：当单台机器上所有入口流量的 QPS 达到阈值即触发系统保护。

重要的属性

Field	说明	默认值
highestSystemLoad	load1 触发值，用于触发自适应控制阶段	-1 (不生效)
avgRt	所有入口流量的平均响应时间	-1 (不生效)
maxThread	入口流量的最大并发数	-1 (不生效)
qps	所有入口资源的 QPS	-1 (不生效)
highestCpuUsage	当前系统的 CPU 使用率（0.0-1.0）	-1 (不生效)

注意系统规则只针对入口资源（EntryType=IN）生效。

这里演示如何使用所有入口资源的QPS配置规则

实现步骤

系统自适应保护规则设置有两种方式

本地代码设置
在Sentinel控制台动态设置

本地代码设置

创建SysController，在其中编写修改以下代码

@RestController
public class SysController {

    //定义限流资源和限流讲解回调函数
    @SentinelResource(entryType = EntryType.IN)
    @GetMapping("sys")
    public String hello() {

        return "Hello Sentinel!";
    }

    /**
     * 定义系统自适应规则
     * @PostConstruct ：在构造函数执行完毕后执行
     */
    @PostConstruct
    private void initSystemRule() {
        //1.创建系统自适应规则的集合
        List<SystemRule> rules = new ArrayList<>();
        //2.创建系统自适应规则
        SystemRule rule = new SystemRule();
        //设置根据入口QPS规则
        rule.setQps(2);
        //将系统自适应规则添加到集合中
        rules.add(rule);

        //3.加载系统自适应规则
        SystemRuleManager.loadRules(rules);
    }
}

运行测试

通过浏览器输入http://localhost:8080/sys，慢速刷新，则持续显示”Hello Sentinel”；快速刷新则会交替出现”Hello Sentinel”和“Blocked by Sentinel (flow limiting)”。这说明系统自适应保护规则设置成功。

在Sentinel控制台动态设置

将SysController中的代码设置系统自适应保护规则删除，重启项目，在Sentinel控制台动态设置系统自适应保护规则。

在Sentinel控制台的左侧菜单中选择“系统规则”，点击“新增系统规则”按钮，设置系统自适应保护规则，其中阈值类型选择“入口QPS”。

之后，通过浏览器输入http://localhost:8080/sys，慢速刷新，则持续显示”Hello Sentinel”；快速刷新则会交替出现”Hello Sentinel”和“Blocked by Sentinel (flow limiting)”。这说明系统自适应保护规则设置成功。

3.12 授权控制实现

很多时候，我们需要根据调用来源来判断该次请求是否允许放行，这时候可以使用 Sentinel 的来源访问控制（黑白名单控制）的功能。来源访问控制根据资源的请求来源（origin）判断资源访问是否通过，若配置白名单则只有请求来源位于白名单内时才可通过；若配置黑名单则请求来源位于黑名单时不通过，其余的请求通过。

重要的属性

来源访问控制规则（AuthorityRule）非常简单，主要有以下配置项：

resource：资源名，即限流规则的作用对象。
limitApp：请求来源，对应的黑名单/白名单，多个用","分隔，如 appA,appB。
strategy：限制模式，AUTHORITY_WHITE为白名单模式，AUTHORITY_BLACK为黑名单模式，默认为白名单模式。

实现步骤

这里演示实现Ip地址白名单和黑名单配置规则

授权控制规则设置有两种方式

本地代码设置
在Sentinel控制台动态设置

本地代码设置

1.创建WhiteBlackController，在其中编写修改以下代码

java

@RestController
public class WhiteBlackController {

    //定义限流资源和限流讲解回调函数
    @SentinelResource(value = "Sentinel_Rule", blockHandler = "exceptionHandler")
    @GetMapping("origin")
    public String hello() {
        return "Hello Sentinel!";
    }

    // blockHandler函数，原方法调用被限流/降级/系统保护的时候调用
    public String exceptionHandler(BlockException ex) {
        ex.printStackTrace();
        return "系统繁忙，请稍候";
    }

    /**
     * 白名单设置
     *
     * @PostConstruct ：在构造函数执行完毕后执行
     */
    @PostConstruct
    private static void initWhiteRules() {
        //1.创建存放授权规则的集合
        List<AuthorityRule> rules = new ArrayList<AuthorityRule>();

        //2.创建授权规则
        AuthorityRule rule = new AuthorityRule();
        //定义资源
        rule.setResource("Sentinel_Rule");
        //设置授权模式 RuleConstant.AUTHORITY_WHITE ：白名单
        rule.setStrategy(RuleConstant.AUTHORITY_WHITE);
        //设置白名单
        rule.setLimitApp("192.168.0.100");
        //将授权规则添加到集合中
        rules.add(rule);

        //3.加载授权规则
        AuthorityRuleManager.loadRules(rules);
    }

    /**
     * 黑名单设置
     *
     * @PostConstruct ：在构造函数执行完毕后执行
     */
    @PostConstruct
    private static void initBlackRules() {
        //1.创建存放授权规则的集合
        List<AuthorityRule> rules = new ArrayList<AuthorityRule>();

        //2.创建授权规则
        AuthorityRule rule = new AuthorityRule();
        //定义资源
        rule.setResource("Sentinel_Rule");
        //设置授权模式 RuleConstant.AUTHORITY_BLACK ：黑名单
        rule.setStrategy(RuleConstant.AUTHORITY_BLACK);
        //设置黑名单
        rule.setLimitApp("127.0.0.1");
        //将授权规则添加到集合中
        rules.add(rule);

        //3.加载授权规则
        AuthorityRuleManager.loadRules(rules);

    }
}

白名单和黑名单只要配置一个就可以满足需求。

2.创建SentinelConfig，设置请求来源解析

java

@Component
public class SentinelConfig {
    @PostConstruct
    public void init(){
        //获取请求来源ip地址
        WebCallbackManager.setRequestOriginParser(new RequestOriginParser() {
            @Override
            public String parseOrigin(HttpServletRequest httpServletRequest) {
                return httpServletRequest.getRemoteAddr();
            }
        });
    }
}

3.运行测试

通过浏览器输入http://192.168.0.100:8080/origin进行访问，则显示”Hello Sentinel”；当浏览器输入http://127.0.0.1:8080/origin，则显示”系统繁忙，请稍候”，这说明授权控制规则设置成功。

在Sentinel控制台动态设置

将WhiteBlackController中的代码设置授权控制规则删除，重启项目，在Sentinel控制台动态设置授权控制规则。

在Sentinel控制台的左侧菜单中选择“授权规则”，点击“新增授权规则”按钮，增加白名单或者黑名单。

之后，通过浏览器输入http://192.168.0.100:8080/origin进行访问，则显示”Hello Sentinel”；当浏览器输入http://127.0.0.1:8080/origin，则显示”系统繁忙，请稍候”，这说明授权控制规则设置成功。

3.13 动态规则扩展实现

不管是通过Java代码还是通过Sentinel控制台的方式去设置限流规则，都属于手动方式，不够灵活。这种方式一般仅用于测试和演示，生产环境上一般通过动态规则源的方式来动态管理限流规则。也就是说，很多时候限流规则会被存储在文件、数据库或者配置中心当中。Sentinel的DataSource 接口给我们提供了对接任意配置源的能力。

官方推荐通过控制台设置规则后将规则推送到统一的规则管理中心，客户端实现 ReadableDataSource 接口端监听规则中心实时获取变更，流程如下：

常见的实现方式有:

拉取式：客户端主动向某个规则管理中心定期轮询拉取规则，这个规则管理中心可以是文件，甚至是 VCS 等。这样做的方式是简单，缺点是无法及时获取变更；实现拉模式的数据源最简单的方式是继承AutoRefreshDataSource 抽象类，然后实现 readSource()方法，在该方法里从指定数据源读取字符串格式的配置数据。
推送式：规则管理中心统一推送，客户端通过注册监听器的方式时刻监听变化，比如使用 Zookeeper 、Apollo等作为规则管理中心。这种方式有更好的实时性和一致性保证。实现推模式的数据源最简单的方式是继承 AbstractDataSource抽象类，在其构造方法中添加监听器，并实现 readSource() 从指定数据源读取字符串格式的配置数据。

使用zookeeper配置规则

Sentinel 针对 ZooKeeper 作了相应适配，底层可以采用 ZooKeeper 作为规则配置数据源。使用时只需添加sentinel-datasource-zookeeper

1.新建工程sentinel_zookeeper，在pom.xml文件引入依赖

xml

<!--Spring Cloud Alibaba Sentinel依赖-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
    <version>2.1.0.RELEASE</version>
</dependency>

<!--sentinel适配zookeeper的依赖-->
<dependency>
     <groupId>com.alibaba.csp</groupId>
     <artifactId>sentinel-datasource-zookeeper</artifactId>
     <version>1.7.2</version>
</dependency>

2.在application.properties中配置连接sentinel控制台

properties

# 设置应用的名称
spring.application.name=SentinelZookeeper
# 设置Sentinel连接控制台的主机地址和端口
spring.cloud.sentinel.transport.dashboard=localhost:9000

3.创建ZookeeperSentinelConfig，设置客户端修改获取规则的地方为从zookeeper获取规则。

java

@Component
public class ZookeeperSentinelConfig {

    /**
     * 连接zookeeper获取规则
     */
    @PostConstruct
    public void loadRules(){
        //Zookeeper 服务端的连接地址
        String remoteAddress = "127.0.0.1:2181";
        //Zookeeper中的数据路径
        String path = "/Sentinel/zookeeper";


        //构建资源
        //参数1：zookeeper服务端地址
        //参数2：zookeeper数据路径
        //参数3：设置存放数据类型
        ReadableDataSource<String, List<FlowRule>> readableDataSource = new ZookeeperDataSource<>(
                remoteAddress,
                path,
                source -> JSON.parseObject(source, new TypeReference<List<FlowRule>>() {})
        );

        //将数据资源注册到FlowRuleManager
        FlowRuleManager.register2Property(readableDataSource.getProperty());
    }
}

4.创建ZookeeperController，设置流控资源配置

java

@RestController
public class ZookeeperController {

    //定义限流资源和限流讲解回调函数
    @SentinelResource(value = "Sentinel_Zookeeper",blockHandler = "exceptionHandler")
    @GetMapping("zookeeper")
    public String hello() {

        return "Hello Sentinel!";
    }

    // blockHandler函数，原方法调用被限流/降级/系统保护的时候调用
    public String exceptionHandler(BlockException ex) {
        ex.printStackTrace();
        return "系统繁忙，请稍候";
    }
}

5.创建单元测试，编写代码，模拟往zookeeper中传递规则，然后再从客户端获取

java

@RunWith(SpringRunner.class)
@SpringBootTest
public class SentinelZookeeperApplicationTests {

    @Test
    public void contextLoads() throws Exception {
        //zookeeper的服务端连接地址
        final String remoteAddress = "127.0.0.1:2181";

        //发送的规则
        //resource : 资源名
        //controlBehavior：流控效果
        //count：阀值
        //grade：规则类型
        //limitApp：调用来源
        //strategy：判断根据是资源自身，还是根据其他关联资源，还是根据链路入口
        final String rule = "[\n"
                + "  {\n"
                + "    \"resource\": \"Sentinel_Zookeeper\",\n"
                + "    \"controlBehavior\": 0,\n"
                + "    \"count\": 2.0,\n"
                + "    \"grade\": 1,\n"
                + "    \"limitApp\": \"default\",\n"
                + "    \"strategy\": 0\n"
                + "  }\n"
                + "]";
        //创建连接zookeeper
        CuratorFramework zkClient = CuratorFrameworkFactory.newClient(remoteAddress, new ExponentialBackoffRetry
                (1000, 3));
        //开始连接
        zkClient.start();
        //配置zookeeper数据路径
        String path = "/Sentinel/zookeeper";
        Stat stat = zkClient.checkExists().forPath(path);
        //发送数据给zookeeper
        if (stat == null) {
            zkClient.create().creatingParentContainersIfNeeded().withMode(CreateMode.PERSISTENT).forPath(path, null);
        }
        zkClient.setData().forPath(path, rule.getBytes());

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //关闭连接
        zkClient.close();

    }

}

6.运行测试

启动本地zookeeper。

启动项目，查看Idea打印台日志，查看项目是否连接了zookeeper。

在浏览器输入http://localhost:8080/zookeeper，查看页面是否能显示请求返回的“Hello Sentinel!”。

但是这个时候是没有流控规则的，也就是连续刷新，页面始终会显示“Hello Sentinel!”。

运行单元测试，向zookeeper发送流控规则，查看Idea打印台查看是否想zookeeper发送流控规则成功

四、拓展知识

4.1 Hystrix 迁移方案

Sentinel官网提供了详细的由Hystrix 迁移到Sentinel 的方法

Hystrix 功能	迁移方案
线程池隔离/信号量隔离	Sentinel 不支持线程池隔离；信号量隔离对应 Sentinel 中的线程数限流详情
熔断器	Sentinel 支持按平均响应时间、异常比率、异常数来进行熔断降级。从 Hystrix 的异常比率熔断迁移的步骤详情
Command创建	直接使用 Sentinel SphU API 定义资源即可，资源定义与规则配置分离详情
规则配置	在 Sentinel 中可通过 API 硬编码配置规则，也支持多种动态规则源
注解支持	Sentinel 也提供注解支持，可以很方便地迁移详情
开源框架支持	Sentinel 提供 Servlet、Dubbo、Spring Cloud、gRPC 的适配模块，开箱即用；若之前使用 Spring Cloud Netflix，可迁移至 Spring Cloud Alibaba

五、安装

5.1 常规安装

控制台

sentinel官方提供了UI控制台，方便对系统做限流设置。可以在GitHub下载。

从项目地址下载jar包后，运行

shell

java -jar sentinel-dashboard-1.8.1.jar

修改Sentinel的默认端口、账户、密码，可以通过下列配置：

配置项	默认值	说明
server.port	8080	服务端口
sentinel.dashboard.auth.username	sentinel	默认用户名
sentinel.dashboard.auth.password	sentinel	默认密码

例如，修改端口：

java -Dserver.port=8090 -jar sentinel-dashboard-1.8.1.jar

服务访问地址：ip+端口。用户名和密码都是sentinel。

可以参考鉴权模块文档配置用户名和密码

客户端接入控制台

引入JAR包

xml

<dependency> 
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-transport-simple-http</artifactId> 
</dependency>

配置启动参数

yaml

spring:
  cloud:
    sentinel:
      transport: 
        dashboard: localhost:8080

默认情况下Sentinel 会在客户端首次调用的时候进行初始化，开始向控制台发送心跳包。也可以配置sentinel.eager=true ,取消Sentinel控制台懒加载。

打开浏览器即可展示Sentinel的管理控制台

一、概述 ​

1.1 相关概念 ​

1.2 系统负载保护 ​

1.3 工作机制 ​

1.4 簇点网络 ​

1.5 限流 ​

流控模式 ​

流控效果 ​

二、应用示例 ​

2.1 流控降级示例 ​

本地应用创建 ​

定义使用限流规则 ​

本地Sentinel控制台搭建 ​

应用接入控制台 ​

2.2 与springcloud整合 ​

依赖 ​

配置 ​

使用示例 ​

2.3 与Feign的集成 ​

依赖 ​

启用Eureka ​

配置 ​

Feign代理接口 ​

创建FallbackService ​

创建controller ​

测试 ​

2.4 与gateway集成 ​

依赖 ​

启用Eureka ​

配置 ​

配置类 ​

流控规则测试 ​

route维度规则定义 ​

自定义 API 维度 ​

三、核心知识 ​

3.1 定义资源方式 ​

抛出异常的方式定义资源 ​

返回布尔值方式定义资源 ​

异步调用支持 ​

注解方式定义资源 ​

主流框架的默认适配 ​

3.2 热点参数限流 ​

3.3 隔离和降级 ​

1. Rest实现熔断 ​

2. FeignClient整合Sentinel ​

3. 线程隔离 ​

4. 熔断降级 ​

熔断降级实现 ​

3.4 授权 ​

3.5 系统规则 ​

3.6 异常 ​

参数 ​

异常子类 ​

自定义异常处理类 ​

3.7 @SentinelResource使用 ​

主要参数 ​

定义限流和降级后的处理方法 ​

**方式1：**直接将限流和降级方法定义在方法中 ​

方式二: 将限流和降级方法外置到单独的类中 ​

3.8 @SentinelRestTemplate ​

3.9 规则持久化 ​

1. pull模式 ​

2. push模式 ​

自定义实现持久化 ​

通过nacos获取配置 ​

3.10 流量控制实现 ​

3.11 系统自适应保护实现 ​

支持模式 ​

重要的属性 ​

实现步骤 ​

本地代码设置 ​

在Sentinel控制台动态设置 ​

3.12 授权控制实现 ​

重要的属性 ​

实现步骤 ​

本地代码设置 ​

在Sentinel控制台动态设置 ​

3.13 动态规则扩展实现 ​

使用zookeeper配置规则 ​

四、拓展知识 ​

一、概述

1.1 相关概念

1.2 系统负载保护

1.3 工作机制

1.4 簇点网络

1.5 限流

流控模式

流控效果

二、应用示例

2.1 流控降级示例

本地应用创建

定义使用限流规则

本地Sentinel控制台搭建

应用接入控制台

2.2 与springcloud整合

依赖

配置

使用示例

2.3 与Feign的集成

依赖

启用Eureka

配置

Feign代理接口

创建FallbackService

创建controller

测试

2.4 与gateway集成

依赖

启用Eureka

配置

配置类

流控规则测试

route维度规则定义

自定义 API 维度

三、核心知识

3.1 定义资源方式

抛出异常的方式定义资源

返回布尔值方式定义资源

异步调用支持

注解方式定义资源

主流框架的默认适配

3.2 热点参数限流

3.3 隔离和降级

1. Rest实现熔断

2. FeignClient整合Sentinel

3. 线程隔离

4. 熔断降级

熔断降级实现

3.4 授权

3.5 系统规则

3.6 异常

参数

异常子类

自定义异常处理类

3.7 @SentinelResource使用

主要参数

定义限流和降级后的处理方法

方式1：直接将限流和降级方法定义在方法中

方式二: 将限流和降级方法外置到单独的类中

3.8 @SentinelRestTemplate

3.9 规则持久化

1. pull模式

2. push模式

自定义实现持久化

通过nacos获取配置

3.10 流量控制实现

3.11 系统自适应保护实现

支持模式

重要的属性

实现步骤

本地代码设置

在Sentinel控制台动态设置

3.12 授权控制实现

重要的属性

实现步骤

本地代码设置

在Sentinel控制台动态设置

3.13 动态规则扩展实现

使用zookeeper配置规则

四、拓展知识